Please address the comments from this code review:

## Overall Comments
- In `LongTermMemory._json_safe` you call `isinstance(value, list | tuple)`, but `list | tuple` creates a `types.UnionType` which `isinstance` does not accept and will raise a `TypeError`; use a tuple of types instead (e.g., `isinstance(value, (list, tuple))`).

## Individual Comments

### Comment 1
<location path="astrbot/builtin_stars/astrbot/long_term_memory.py" line_range="239" />
<code_context>
+            return await self._json_safe(value.toDict())
+        if isinstance(value, dict):
+            return {k: await self._json_safe(v) for k, v in value.items()}
+        if isinstance(value, list | tuple):
+            return [await self._json_safe(item) for item in value]
+        return value
</code_context>
<issue_to_address>
**issue (bug_risk):** Using `isinstance(value, list | tuple)` will raise at runtime; `isinstance` does not accept `|` unions here.

`isinstance` requires a type or a tuple of types as its second argument; `list | tuple` (PEP 604 union) will raise `TypeError` at runtime, so this branch will fail for lists/tuples. Use `isinstance(value, (list, tuple))`, or `collections.abc.Sequence` if you need broader sequence support.
</issue_to_address>

### Comment 2
<location path="astrbot/builtin_stars/astrbot/long_term_memory.py" line_range="224-225" />
<code_context>
+        return content
+
+    async def _component_to_json_safe_dict(self, comp) -> dict:
+        if hasattr(comp, "to_dict"):
+            data = await comp.to_dict()
+        elif hasattr(comp, "toDict"):
+            data = comp.toDict()
</code_context>
<issue_to_address>
**issue (bug_risk):** Blindly awaiting `comp.to_dict()` assumes it is async; if it is sync this will fail at runtime.

Both `_component_to_json_safe_dict` and `_json_safe` currently assume any `to_dict` is async. If `to_dict` is a regular sync method returning a dict (a common case), `await comp.to_dict()` will raise `TypeError: object dict can't be used in 'await' expression`. Consider checking whether `to_dict` is awaitable (e.g. via `inspect.iscoroutinefunction` / `inspect.isawaitable`) and only `await` it when appropriate, otherwise call it synchronously.
</issue_to_address>